41. 数据结构之元组

# 方式1: 使用圆括号创建元组
# 圆括号是可选的，但加上可以提高代码可读性
tup1 = ('physics', 'chemistry', 1997, 2000)  # 包含字符串和整数的混合元组
tup2 = (1, 2, 3, 4, 5)  # 纯整数元组
tup3 = "a", "b", "c", "d"  # 不加括号也可以，Python会自动识别为元组

# 创建空元组
# 空元组常用于初始化变量或作为函数默认参数
empty_tup = ()

# 创建单元素元组(注意逗号!)
# 这是一个常见的陷阱：单个元素后面必须有逗号，否则会被识别为带括号的表达式
single_tup = (50,)  # 正确：有逗号，是元组
not_a_tuple = (50)  # 错误：没有逗号，这只是整数50

# 打印结果以验证类型
print('元组1:', tup1)
print('元组2:', tup2)
print('元组3:', tup3)  # 证明不加括号也能创建元组
print('空元组:', empty_tup)
print('单元素元组:', single_tup)

# 从列表创建元组
list_data = [1, 2, 3, 4]
tup_from_list = tuple(list_data)

# 从字符串创建元组(每个字符成为一个元素)
tup_from_string = tuple('Hello')

# 从range对象创建元组
tup_from_range = tuple(range(5))

print('从列表:', tup_from_list)
print('从字符串:', tup_from_string)
print('从range:', tup_from_range)

# 使用生成器表达式创建元组
# 生成器表达式用圆括号表示，然后传给tuple()函数
squares = tuple(x**2 for x in range(6))

# 这等价于先创建列表再转换，但更节省内存
# 因为生成器是惰性求值的，不需要创建中间列表

print('平方数元组:', squares)

# 创建示例元组
tup1 = ('physics', 'chemistry', 1997, 2000)  # 混合类型元组
tup2 = (1, 2, 3, 4, 5, 6, 7)  # 纯数字元组

# 正向索引：从0开始，从左向右数
print('tup1[0]:', tup1[0])  # 第一个元素：'physics'
print('tup1[1]:', tup1[1])  # 第二个元素：'chemistry'

# 负向索引：从-1开始，从右向左数
print('tup2[-1]:', tup2[-1])  # 最后一个元素：7
print('tup2[-2]:', tup2[-2])  # 倒数第二个元素：6

# 切片操作：获取子元组
# 语法：tup[start:end:step]
# start包含，end不包含(左闭右开区间)
print('tup2[1:5]:', tup2[1:5])  # 索引1到4的元素：(2, 3, 4, 5)
print('tup2[::2]:', tup2[::2])  # 每隔一个取一个：(1, 3, 5, 7)
print('tup2[::-1]:', tup2[::-1])  # 反转元组：(7, 6, 5, 4, 3, 2, 1)

tup = (1, 2, 3)

# 下面的代码会抛出IndexError
try:
    print(tup[10])  # 索引10不存在
except IndexError as e:
    print(f'错误：索引超出范围 - {e}')

# 创建一个元组
tup = (12, 34.56)

# 尝试修改元组的第一个元素
try:
    tup[0] = 20  # 这会抛出TypeError
except TypeError as e:
    print(f'错误类型: {type(e).__name__}')
    print(f'错误信息: {e}')
    print('结论：元组外层槽位一旦创建就不能重绑')  # 该报错不证明内部可变对象被固定

# 虽然不能修改，但可以连接两个元组创建新元组
# 注意：这不是修改原元组，而是创建了一个全新的元组
tup3 = tup + ('abc', 'xyz')
print('原元组:', tup)  # 原元组保持不变
print('新元组:', tup3)  # 这是一个新创建的元组

# 也可以通过重复创建新元组
tup4 = tup * 2  # 元组重复
print('重复元组:', tup4)

# 定义交易策略的核心参数
# 使用元组避免外层参数被意外改动；实际设置仍需检查、授权并记录版本
trading_params = (
    100000,    # 初始资金(元)
    0.05,       # 预期年收益率
    30,         # 投资期限(年)
    0.6         # 股票配置比例
)

# 元组解包：将元组的元素分别赋值给变量
# 这种写法比分别访问元组元素更清晰
initial_capital, rate, years, stock_ratio = trading_params

# 格式化输出参数
# 使用f-string进行格式化，提高可读性
print(f'初始资金: {initial_capital:,.0f}元')  # 添加千位分隔符
print(f'年利率: {rate:.1%}')  # 百分比格式
print(f'投资期限: {years}年')
print(f'股票配置: {stock_ratio:.0%}')

# 计算期末资产
final_amount = initial_capital * (1 + rate) ** years
print(f'期末资产(复利): {final_amount:,.2f}元')

# 创建价格查找表
# 键是(股票代码, 日期)的元组，值是收盘价
price_lookup = {
    ('600519.SH', '2024-01-15'): 1856.00,
    ('600519.SH', '2024-01-16'): 1862.50,
    ('000858.SZ', '2024-01-15'): 158.20,
    ('000858.SZ', '2024-01-16'): 159.80
}

# 查询特定股票在特定日期的价格
stock = '600519.SH'
date = '2024-01-15'
price = price_lookup.get((stock, date))

if price:
    print(f'{stock} 在 {date} 的收盘价是 {price:.2f}元')
else:
    print('未找到匹配的价格数据')

# 字典键必须可哈希；元组仅在每个成员及其嵌套成员均可哈希时才能作为键
# 下面的代码会报错，因为列表是可变的：
# error_dict = {['600519.SH', '2024-01-15']: 1856.00}  # TypeError

def calculate_return_metrics(prices):
    '''
    计算价格序列的多个收益率指标

    参数:
        prices: 价格列表

    返回:
        (总收益率, 年化收益率, 波动率)的元组
    '''
    import numpy as np

    # 计算简单收益率
    returns = np.diff(prices) / prices[:-1]

    # 总收益率
    total_return = (prices[-1] - prices[0]) / prices[0]

    # 年化收益率(假设252个交易日)
    annual_return = (1 + total_return) ** (252 / len(prices)) - 1

    # 年化波动率
    annual_volatility = returns.std() * np.sqrt(252)

    return total_return, annual_return, annual_volatility

# 使用示例
stock_prices = [100, 102, 101, 105, 108, 107, 110]
total_ret, ann_ret, ann_vol = calculate_return_metrics(stock_prices)

print(f'总收益率: {total_ret:.2%}')
print(f'年化收益率: {ann_ret:.2%}')
print(f'年化波动率: {ann_vol:.2%}')

# 定义一个时间戳数据点
tick = ('600519.SH', '2024-01-15 09:30:00', 1856.00, 100)
# 格式：(股票代码, 时间戳, 价格, 成交量)

# 元组解包提取字段
symbol, timestamp, price, volume = tick

print(f'股票代码: {symbol}')
print(f'时间戳: {timestamp}')
print(f'价格: {price:.2f}元')
print(f'成交量: {volume}手')

# 将多个tick数据组成列表
ticks = [
    ('600519.SH', '09:30:00', 1856.00, 100),
    ('600519.SH', '09:31:00', 1858.50, 150),
    ('600519.SH', '09:32:00', 1855.00, 80),
]

# 分析第一分钟的价格变化
price_change = ticks[1][2] - ticks[0][2]
print(f'第一分钟价格变化: {price_change:+.2f}元')

import sys
import timeit

# 创建相同内容的元组和列表
tup = tuple(range(1000))
lst = list(range(1000))

# 内存占用比较
print(f'元组内存占用: {sys.getsizeof(tup)} 字节')
print(f'列表内存占用: {sys.getsizeof(lst)} 字节')
print(f'元组更节省: {sys.getsizeof(lst) - sys.getsizeof(tup)} 字节')

# 在同一进程做访问时间微基准；结果只代表本次环境与负载
tup_time = timeit.timeit('x = tup[500]', globals=globals(), number=1000000)
lst_time = timeit.timeit('x = lst[500]', globals=globals(), number=1000000)

print(f'元组访问时间: {tup_time:.4f}秒')
print(f'列表访问时间: {lst_time:.4f}秒')
print(f'本次元组相对列表时间差: {(lst_time/tup_time - 1)*100:.1f}%')  # 正值表示本次元组更快，负值表示更慢

from collections import namedtuple

# 定义一个命名元组类型
# 相当于创建了一个简单的类
Stock = namedtuple('Stock', ['symbol', 'price', 'volume'])

# 创建Stock实例
stock1 = Stock('600519.SH', 1856.00, 1000)
stock2 = Stock(symbol='000858.SZ', price=158.20, volume=5000)

# 可以像元组一样索引访问
print(f'股票代码(索引): {stock1[0]}')

# 也可以像对象一样属性访问
print(f'股票代码(属性): {stock1.symbol}')
print(f'价格: {stock1.price}')
print(f'成交量: {stock1.volume}')

# 命名元组仍是元组，只保证外层槽位不可重绑
print(f'是否为元组: {isinstance(stock1, tuple)}')

# 命名元组有友好的字符串表示
print(f'股票信息: {stock1}')